<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>
<script>
    //31、以下的代码执行后，控制台里打印的内容为：
    // var a;
    // var b = 'undefined';
    // console.log(typeof a);//undefined
    // console.log(typeof b);//string
    // console.log(typeof c);//undefined
    //32、以下的代码执行后，控制台里打印的内容为：
    // var obj = { n: 1 };
    // function fn2(a) {
    //     a.n = 2;
    // }
    // fn2(obj);
    // console.log(obj.n);//2

    //33、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //执行show(fn)，fn()被作为参数带入，那么就是执行fn(),
    //fn()函数中并没有局部变量，所以调用全局变量x=10，并将它打印出来，
    //和show()函数中的变量并没有关系，那么最后结果就是10啦。
    // var x = 10;
    // function fn() {
    //     console.log(x);//10
    // }
    // function show(f) {
    //     var x = 20;
    //     fn();
    // }
    // show(fn);

    //34、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //hasOwnProperty是Object.prototype的一个方法，
    //他能判断一个对象是否包含自定义属性而不是原型链上的属性，
    //因为hasOwnProperty 是 JavaScript 中唯一一个处理属性但是不查找原型链的函数。

    // Object.prototype.bar = 1;
    // var foo = {
    //     goo: undefined
    // };
    // console.log(foo.bar);//1
    // console.log('bar' in foo);//true
    // console.log(foo.hasOwnProperty('bar'));//false
    // console.log(foo.hasOwnProperty('goo'));//true

    // //35、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //同时在使用 for in loop 遍历对象时，推荐总是使用 hasOwnProperty 方法，
    //这将会避免原型对象扩展带来的干扰
    // Object.prototype.bar = 1;
    // var foo = {
    //     moo: 2,
    // }
    // for (var i in foo) {
    //     console.log(i); // 输出两个属性：bar 和 moo
    // }

    // //36、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //调用函数foo1 返回的是一个对象{bar:"hello"}；
    //调用函数foo2 返回的是一个对象{bar:"hello"};
    // function foo1() {
    //     return {
    //         bar: 'hello'
    //     };
    // }
    // function foo2() {
    //     return {
    //         bar: 'hello'
    //     };
    // }
    // console.log(foo1());//{bar:"hello"}
    // console.log(foo2());//{bar:"hello"}

    // //37、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //arguments：实参的集合，是一个类数组，他有数组的长度，
    //可以循环，但是他没有数组的方法，如push()等。输出：“object”
    // console.log(function () {
    //     return typeof arguments;
    // }())//object

    // //38、以下的代码执行后，控制台里打印的内容为：
    // console.log(Boolean(false));//false
    // console.log(Boolean('0'));//true
    // console.log(Boolean(''));//false
    // console.log(Boolean(NaN));//false

    // //39、以下的代码执行后，控制台里打印的内容为：
    //解析：
    //条件判断为假的情况有： 0 、false 、'' 、 null 、undefined 、未定义对象。
    //函数声明写在运算符中，其为 true，但 放在运算符中的函数声明在执行阶段时找不到的 。
    //另外，对未声明的变量执行 typeof 不会报错，会返回 undefined
    // var x = 1;
    // if (function f() { }) {
    //     x + typeof f;
    // }
    // console.log(x);//1

    // //40、以下的代码执行后，控制台里打印的内容为：
    // console.log('b' + 'a' + + +'a' + 'a')//baNaNa

    // //41、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //只能遍历可枚举的属性，不管是自己的还是原型的
    // var obj = {
    //     a: 1,
    //     b: 2
    // }
    // Object.setPrototypeOf(obj, { c: 3 });
    // Object.defineProperty(obj, 'd', { value: 4, enumerable: false });
    // for (let prop in obj) {
    //     console.log(prop);//a b c
    // }

    // //42、以下的代码执行后，控制台里打印的内容为：
    //解析:
    //首先我们可以看到var x是一个全局遍历，在不是严格模式下，
    //这个X就直接是window对象的属性了。在这段代码里，我们最重要是要
    //理解this的对象指向问题，this始终是指向调用方法的对象的。所以，在foo,xGetter()的情况下，
    //this指向的是foo对象，返回的就是在foo中的属性x，值就是90。但是在xGetter（）的情况下，
    //他是直接调用的foo的getx()方法，但是其中this的指向是在xGetter的作用域，就是指向的window对象中，
    //这时指向的就是全局变量x了，值也就是10。
    // var x = 10;// 全局变量
    // var foo = {
    //     x: 90,//foo对象的内部属性
    //     getX: function () {
    //         return this.x;
    //     }
    // };
    // console.log(foo.getX());// 此时是指向的foo对象，
    // // 此时是指向的foo对象，
    // var xGetter = foo.getX;//xGetter是在全局作用域，
    // //这里的this就是指向window对象
    // console.log(xGetter());//打印 10

    // //43、写一个sum方法，当使用下面的语法调用时它将正常工作：
    // console.log(sum(2, 3));//未捕获引用错误：未定义总和
    // console.log(sum(2)(3))//未捕获引用错误：未定义总和

    // //44、当用户点击“按钮4”时什么被记录到控制台？为什么？
    //假如您需要运行代码多次，且每次使用不同的值，那么循环（loop）相当方便使用。
    // for (var i = 0; i < 5; i++) {
    //     var btn = document.createElement('button');
    //     btn.appendChild(document.createTextNode('按钮' + i));
    //     btn.addEventListener('click', function () {
    //         console.log(i);
    //     })
    //     document.body.appendChild(btn);
    // }

    // //45、以下代码执行后，d里的内容为？
    // var d = {};
    // var b = ['car', 'house'];
    // b.forEach(function (k) {
    //     d[k] = undefined;
    // })
    // console.log(d);//{car: undefined, house: undefined}

    // //46、以下代码执行后，控制台里的内容为？
    // var arr1 = 'john'.split('');
    // var arr2 = arr1.reverse();
    // var arr3 = 'jones'.split('');
    // arr2.push(arr3);
    // console.log('arr1:length=' + arr1.length + 'last=' + arr1.splice(-1));//arr1:length=5last=j,o,n,e,s
    // console.log('arr2:length=' + arr2.length + 'last=' + arr2.splice(-1));//arr2:length=4last=j

    // //47、以下代码执行后，控制台里的内容为？
    // console.log("0 || 1=" + (0 || 1));//0 || 1=1
    // console.log('1 || 2=' + (1 || 2));//1 || 2=1
    // console.log('0&&1=' + (0 && 1));//0&&1=0
    // console.log('1&&2' + (1 && 2));//1&&22

    // //48、以下代码执行后，控制台里的内容为？
    // var a = {}
    // b = { key: 'b' };
    // c = { key: 'c' };
    // a[b] = 123;
    // a[c] = 456;
    // console.log(a[b]);//456
    // console.log(a[c]);//456

    // //49、以下代码执行后，控制台里的内容为？
    // (function (x) {
    //     return (function (y) {
    //         console.log(x);//1
    //     })(2)
    // })(1);

    //50、以下代码执行后，控制台里的内容为？
    // var length = 10;
    // function fn() {
    //     console.log(this.length);//10 2
    // }
    // var obj = {
    //     length: 5,
    //     method: function (fn) {
    //         fn();
    //         arguments[0]();
    //     }
    // };
    // obj.method(fn, 1);

    //51、以下代码执行后，控制台里的内容为？
    // var myObject = {
    //     foo: 'bar',
    //     func: function () {
    //         var self = this;
    //         console.log('outer func: this.foo=' + this.foo);//outer func: this.foo=bar
    //         console.log('outer func: self.foo=' + self.foo);//outer func: self.foo=bar
    //         (function () {
    //             console.log('inner func :this.foo=' + this.foo);//inner func :this.foo=undefined
    //             console.log('inner func :self.foo=' + self.foo)//inner func :self.foo=bar
    //         })()
    //     }
    // }
    // myObject.func();

    //52、有关this运算符说法不正确的是？
    //A this表示当前对象的一个引用
    //B 在JS中，由于JS的动态性，this的指向在运行时才正确
    //C this关键字在JavaScript中和执行环境，而非声明环境有关
    //D 通过早期绑定可以实现对this的高度复用

    //53、以下哪个不是JavaScript中的错误类型？
    //A 、语法错误
    //B、系统错误
    //C 、类型错误
    //D 、引用错误

    //54、有关循环语句说法正确的是？
    //- A、for...in循环遍历不到继承的属性
    //- B、do...while在判断条件前会执行一次代码块
    //- C、for循环中三个表达可以省略，分号也可以省略
    //- D、while循环语句至少会执行循环体一次

    //55、如果函数无明确的返回值，或调用了没有参数的return语句，那么它真正返回的值是？
    //A、null
    //B、-1
    //C、0
    //D、undefined

    //56、JavaScript函数中包含了一个参数对象下面有关arguments的描述错误的是？
    //A、arguments是个比较特殊的对象，使用者无需明确指出参数名即可访问到它们
    //B、可以使用arguments的属性length来检测传递给函数的参数个数
    //C、借助于arguments对象，我们可以模拟函数重载
    //D、arguments是一个标准数组

    //57、有关使用typeof运算符的不正确结论是？
    //A、typeof运算符后面的参数可以使用括号引起来，也可以不带括号 //
    //B、typeof运算符的括号里可以放多个参数
    //C、使用typeof运算符检测的返回结果值总是一个小写字符串形式
    //D、typeof 和instanceof可以相互代替

    //58、使用instanceof运算符时正确的结论是？
    //A、一个空对象不能使用instanceof来检测
    //B、instanceof运算符会顺着原型链向上查找
    //C、instanceof的左操作数只能是对象类型的数据
    //D、instanceof可以用来检测数据类型

    //59、给定x=6以及y=3，下列结果正确的是？
    //A、x < 10 && y > 1 的结果为true
    //B、x == 5 || y == 5 的结果为true
    //C、!(x == y)的结果为false
    //D、!!x == x的结果为true
    //

    //60、如下不正确的结论是：
    //A、关系运算符的优先级比'&&'和'||'的要高
    //B、假值是false、null、undefined、0、-0、NaN和''; 所有其它的值(包括所有对象)都是真值
    //C、‘&&’运算符的结果并不一定是布尔值
    //D、关系表达式的运算结果未必总是true或false
    //B
</script>

</html>